Currently, if the layer is constructed with empty perm_, run() fills perm_ once using the first input’s rank. That means calling the same instance later with a different-rank tensor will throw on validate_perm. Prefer computing a local permutation per call when perm_ is empty, e.g.:

void TransposeLayer::run(const Tensor& input, Tensor& output) {
  const auto& shape = input.get_shape();

  std::vector<int64_t> perm = perm_;         // copy member
  if (perm.empty()) {
    perm.resize(shape.dims());
    std::iota(perm.rbegin(), perm.rend(), 0);
  }

  validate_perm(shape /*, perm if you refactor validate_perm to take it */);
  // ... use 'perm' below instead of 'perm_'
}

This keeps the layer usable across inputs of different ranks without surprising statefulness.

Current mapping recomputes old_indices by repeated %// per element. That’s fine for clarity and likely OK at your tensor sizes, but if you profile a hot path, consider:
• Precomputing input/output strides and computing new_index via a dot with mapped coordinates; and/or
• Special-casing 2D transpose to a cache-friendlier kernel.
Not blockers.

run assumes float (input.as(), std::vector). If the framework expects multi-dtype tensors, you’ll want either a templated kernel or a small type-dispatch in run. Tests currently cover only float. Not necessarily required for this PR, but worth tracking.

Reserve capacity for new_dims (new_dims.reserve(shape.dims())).
The out-of-bounds check before writing is defensive; it should be impossible after correct shape math. Keep it or add an assertion instead.

Tests to add (nice-to-have)
• 1D default permutation (rank-1 with empty perm should be a no-op).
• Multiple runs with same instance & different ranks (catches the mutation issue above).